```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>深入理解Java垃圾回收机制</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
            background-color: #f9fafb;
        }
        .hero-bg {
            background: linear-gradient(135deg, #6e8efb 0%, #4a6cf7 100%);
        }
        .card {
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1);
        }
        .section-title {
            position: relative;
            padding-bottom: 0.5rem;
        }
        .section-title:after {
            content: '';
            position: absolute;
            bottom: 0;
            left: 0;
            width: 50px;
            height: 3px;
            background: #4a6cf7;
        }
        .code-block {
            background: #2d3748;
            color: #e2e8f0;
            border-radius: 0.5rem;
            overflow: hidden;
        }
        .first-letter {
            font-size: 3.5rem;
            line-height: 1;
            float: left;
            margin-right: 0.5rem;
            font-weight: bold;
            color: #4a6cf7;
        }
        .footer {
            background: #1a202c;
            color: #a0aec0;
        }
        .footer a:hover {
            color: #ffffff;
        }
        .algorithm-card {
            border-left: 4px solid #4a6cf7;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero-bg text-white py-20 md:py-32">
        <div class="container mx-auto px-6">
            <div class="max-w-4xl mx-auto text-center">
                <h1 class="text-4xl md:text-5xl lg:text-6xl font-bold mb-6">
                    深入理解<span class="text-yellow-300">Java垃圾回收机制</span>
                </h1>
                <p class="text-xl md:text-2xl opacity-90 mb-10 max-w-3xl mx-auto">
                    Java自动内存管理的核心原理与实现细节
                </p>
                <div class="flex justify-center space-x-4">
                    <a href="#intro" class="px-6 py-3 bg-white text-blue-600 font-medium rounded-lg hover:bg-gray-100 transition duration-300">
                        <i class="fas fa-book-open mr-2"></i>开始阅读
                    </a>
                    <a href="#visualization" class="px-6 py-3 border-2 border-white text-white font-medium rounded-lg hover:bg-white hover:text-blue-600 transition duration-300">
                        <i class="fas fa-project-diagram mr-2"></i>可视化图表
                    </a>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto px-6 py-12 max-w-6xl">
        <!-- Introduction Section -->
        <section id="intro" class="mb-20">
            <div class="flex items-center mb-8">
                <i class="fas fa-info-circle text-2xl text-blue-500 mr-3"></i>
                <h2 class="text-3xl font-bold section-title">引言</h2>
            </div>
            <div class="bg-white rounded-xl shadow-md p-8 card">
                <p class="text-lg">
                    <span class="first-letter">J</span>ava语言中一个显著的特点就是引入了垃圾回收机制，使C++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有"作用域"的概念，只有对象的引用才有"作用域"。垃圾回收可以有效的防止内存泄露，有效的使用空闲的内存。
                </p>
            </div>
        </section>

        <!-- What is Garbage Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <i class="fas fa-trash-alt text-2xl text-blue-500 mr-3"></i>
                <h2 class="text-3xl font-bold section-title">垃圾的理解</h2>
            </div>
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white rounded-xl shadow-md p-8 card">
                    <p class="text-lg mb-6">
                        没有被栈指向的堆内存空间就是垃圾，垃圾需要等待GC回收。
                    </p>
                    <div class="bg-gray-100 rounded-lg p-4">
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432781347-f09746a4-5307-4a96-b061-1d7bd1aae0a1.png" alt="垃圾回收示意图" class="rounded-lg w-full">
                    </div>
                </div>
                <div class="bg-white rounded-xl shadow-md p-8 card">
                    <div class="flex items-center mb-4">
                        <i class="fas fa-question-circle text-xl text-blue-500 mr-2"></i>
                        <h3 class="text-xl font-bold">为什么需要垃圾回收机制</h3>
                    </div>
                    <p class="mb-6">
                        如果不进行垃圾回收，内存迟早都会被消耗空，因为我们在不断的分配内存空间而不进行回收。除非内存无限大，我们可以任性的分配而不回收，但是事实并非如此。所以，垃圾回收是必须的。
                    </p>
                    <div class="flex items-center">
                        <i class="fas fa-question-circle text-xl text-blue-500 mr-2"></i>
                        <h3 class="text-xl font-bold">哪些内存需要回收</h3>
                    </div>
                    <p class="mt-4">
                        哪些内存需要回收是垃圾回收机制第一个要考虑的问题，所谓"要回收的垃圾"无非就是那些不可能再被任何途径使用的对象。那么如何找到这些对象？
                    </p>
                </div>
            </div>
        </section>

        <!-- Algorithm Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <i class="fas fa-cogs text-2xl text-blue-500 mr-3"></i>
                <h2 class="text-3xl font-bold section-title">回收算法</h2>
            </div>
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <!-- 引用计数法 -->
                <div class="bg-white rounded-xl shadow-md p-8 algorithm-card card">
                    <h3 class="text-2xl font-bold mb-4 text-blue-600">引用计数法</h3>
                    <div class="code-block mb-6">
                        <pre class="p-4 overflow-x-auto"><code class="language-java">User u1= new User();
User u2 = new User();
User u3 = new User();

// 引用
u1.setUser(u2); // u2被引用的次数+1
u3.setUser(u2); // u2被引用的次数+1

// 释放
u1.setUser(null); // u2被引用的次数-1</code></pre>
                    </div>
                    <p class="mb-6">
                        这种算法的大概思路如下：当对象被创建时，GC程序会存储有多少个引用指向该对象，当没有引用指向该对象时，表示该对象已经不可用，则可以对其进行回收。这种算法相对来说简单粗暴，但是，它不能解决对象之间引用循环指向的问题。
                    </p>
                    <div class="bg-gray-100 rounded-lg p-4">
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432781799-ff8c8c35-0ac8-48d7-b44d-b3878fd3a199.png" alt="引用计数法问题示意图" class="rounded-lg w-full">
                    </div>
                </div>
                
                <!-- 可达性分析法 -->
                <div class="bg-white rounded-xl shadow-md p-8 algorithm-card card">
                    <h3 class="text-2xl font-bold mb-4 text-blue-600">可达性分析法</h3>
                    <p class="mb-4">
                        通过对象的<b>引用链</b>来判断该对象是否需要被回收，通过一系列的GC Roots的对象作为起始点，从这些根节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的，就需要回收此对象。
                    </p>
                    <div class="bg-gray-100 rounded-lg p-4 mb-6">
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432782224-6a956148-c176-493d-a7c8-bd6be07864e8.png" alt="可达性分析法示意图" class="rounded-lg w-full">
                    </div>
                    <div class="mb-6">
                        <h4 class="text-lg font-bold mb-2">什么是 GC Roots 呢？</h4>
                        <p class="mb-2">GC Roots是一些由堆外指向堆内的引用</p>
                        <ul class="list-disc pl-5 space-y-2">
                            <li>虚拟机栈(栈帧中的本地变量表)中引用的对象</li>
                            <li>方法区中静态属性引用的对象</li>
                            <li>方法区中常量引用的对象</li>
                            <li>本地方法栈中(Native方法)引用的对象</li>
                        </ul>
                    </div>
                </div>
            </div>
            
            <!-- 回收时间 -->
            <div class="bg-white rounded-xl shadow-md p-8 mb-12 card">
                <div class="flex items-center mb-4">
                    <i class="fas fa-clock text-xl text-blue-500 mr-2"></i>
                    <h3 class="text-xl font-bold">回收时间</h3>
                </div>
                <div class="grid md:grid-cols-3 gap-6">
                    <div class="bg-blue-50 rounded-lg p-6 text-center">
                        <i class="fas fa-laptop-code text-3xl text-blue-600 mb-3"></i>
                        <h4 class="font-bold mb-2">CPU空闲时</h4>
                        <p>系统CPU空闲时自动进行垃圾回收</p>
                    </div>
                    <div class="bg-blue-50 rounded-lg p-6 text-center">
                        <i class="fas fa-memory text-3xl text-blue-600 mb-3"></i>
                        <h4 class="font-bold mb-2">堆内存满时</h4>
                        <p>当堆内存空间不足时触发垃圾回收</p>
                    </div>
                    <div class="bg-blue-50 rounded-lg p-6 text-center">
                        <i class="fas fa-hand-paper text-3xl text-blue-600 mb-3"></i>
                        <h4 class="font-bold mb-2">手动调用</h4>
                        <p>通过System.gc()方法手动触发</p>
                    </div>
                </div>
            </div>
            
            <!-- 回收方法 -->
            <div class="grid md:grid-cols-3 gap-8">
                <!-- 标记-清除 -->
                <div class="bg-white rounded-xl shadow-md p-8 card">
                    <h3 class="text-2xl font-bold mb-4 text-blue-600">标记-清除算法</h3>
                    <p class="mb-4">
                        首先标记需要回收的对象，然后进行回收
                    </p>
                    <div class="bg-gray-100 rounded-lg p-4 mb-4">
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432782889-b4448048-8555-4a67-a0c1-51a2d88270f6.png" alt="标记-清除算法示意图" class="rounded-lg w-full">
                    </div>
                    <div class="bg-yellow-50 border-l-4 border-yellow-400 p-4">
                        <p class="font-bold text-yellow-700">缺点：</p>
                        <p>回收速度慢，回收之后产生大量不连续的内存碎片，后期运行过程中需要分配较大对象时无法找到足够的连续内存而造成内存空间浪费。</p>
                    </div>
                </div>
                
                <!-- 复制算法 -->
                <div class="bg-white rounded-xl shadow-md p-8 card">
                    <h3 class="text-2xl font-bold mb-4 text-blue-600">复制算法</h3>
                    <p class="mb-4">
                        将内存空间等分为两份，每次只使用其中一份，当满了之后将还有效的对象复制到另一份内存中，然后把原来的空间进行清除，不会产生内存碎片。
                    </p>
                    <div class="bg-gray-100 rounded-lg p-4 mb-4">
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432783271-e819d4ae-adab-489b-b90f-8a3dcd38b585.png" alt="复制算法示意图" class="rounded-lg w-full">
                    </div>
                    <div class="bg-yellow-50 border-l-4 border-yellow-400 p-4">
                        <p class="font-bold text-yellow-700">缺点：</p>
                        <p>可用内存空间减半，内存利用率低。</p>
                    </div>
                </div>
                
                <!-- 标记-整理 -->
                <div class="bg-white rounded-xl shadow-md p-8 card">
                    <h3 class="text-2xl font-bold mb-4 text-blue-600">标记-整理算法</h3>
                    <p class="mb-4">
                        不仅对需要回收的对象进行清理，还对有效对象进行整理，不会产生内存碎片。
                    </p>
                    <div class="bg-gray-100 rounded-lg p-4 mb-4">
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432783595-01baff3f-7fe7-4717-8e9a-08f63387be69.png" alt="标记-整理算法示意图" class="rounded-lg w-full">
                    </div>
                    <div class="bg-yellow-50 border-l-4 border-yellow-400 p-4">
                        <p class="font-bold text-yellow-700">缺点：</p>
                        <p>需要移动存活对象，效率相对较低。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Generational Collection Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <i class="fas fa-layer-group text-2xl text-blue-500 mr-3"></i>
                <h2 class="text-3xl font-bold section-title">分代收集算法</h2>
            </div>
            <div class="bg-white rounded-xl shadow-md p-8 card">
                <p class="mb-6">
                    是一种比较智能的算法，也是现在JVM使用最多的一种算法，其实不是一个新的算法，而是在具体的场景自动选择以上三种算法进行垃圾对象回收。
                </p>
                <div class="grid md:grid-cols-3 gap-8 mb-8">
                    <div class="bg-blue-50 rounded-lg p-6">
                        <h3 class="text-xl font-bold mb-4 text-blue-700 flex items-center">
                            <i class="fas fa-seedling text-blue-500 mr-2"></i>新生代
                        </h3>
                        <p class="mb-4">目的是回收那些生命周期短的对象，主要存放新产生的对象。</p>
                        <p class="font-bold">使用算法：复制算法</p>
                    </div>
                    <div class="bg-purple-50 rounded-lg p-6">
                        <h3 class="text-xl font-bold mb-4 text-purple-700 flex items-center">
                            <i class="fas fa-tree text-purple-500 mr-2"></i>老年代
                        </h3>
                        <p class="mb-4">存放对象生命周期较长，且内存大概是新生代的两倍。</p>
                        <p class="font-bold">使用算法：标记-清除或标记-整理</p>
                    </div>
                    <div class="bg-green-50 rounded-lg p-6">
                        <h3 class="text-xl font-bold mb-4 text-green-700 flex items-center">
                            <i class="fas fa-infinity text-green-500 mr-2"></i>永久代/元空间
                        </h3>
                        <p class="mb-4">主要存放静态文件，如Java类，方法等。JDK1.8开始废弃永久代，使用元空间。</p>
                        <p class="font-bold">内存直接分配在本地内存中</p>
                    </div>
                </div>
                <div class="bg-gray-100 rounded-lg p-6">
                    <h4 class="text-lg font-bold mb-4">总结：</h4>
                    <ul class="list-disc pl-5 space-y-2">
                        <li><b>新生代</b>中：每次垃圾收集时都有大批对象死去，只有少量存活，那就选用复制算法。只需要付出少量存活对象的复制成本就可以完成收集。</li>
                        <li><b>老年代</b>中：因为对象存活率高、没有额外空间对他进行分配担保，就必须用标记-清除或者标记-整理。</li>
                        <li><b>永久代</b>中：经常会内存不够用或者发生内存泄露，JDK1.8开始废弃了永久代，取而代之的是元空间（直接存在内存中可自定义大小）,主要存放类的元数据。</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Reference Types Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <i class="fas fa-link text-2xl text-blue-500 mr-3"></i>
                <h2 class="text-3xl font-bold section-title">四种引用状态</h2>
            </div>
            <div class="bg-white rounded-xl shadow-md p-8 card">
                <p class="mb-6">
                    一个对象只有被引用或者没被引用两种状态，如果引用类型的数据中存储的数值代表的是另一块内存的起始地址，就称这块内存代表着一个引用。
                </p>
                <p class="mb-8">
                    我们希望描述这样一类对象：当内存空间还足够时，则能保留在内存中；如果内存空间在进行垃圾收集后还是非常紧张，则可以抛弃这些对象。在JDK1.2之后，Java对引用的概念进行了扩充，将引用分为<b>强引用、软引用、弱引用、虚引用</b> 4种，这4种引用强度依次减弱。
                </p>
                <div class="bg-gray-100 rounded-lg p-4 mb-8">
                    <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1654432783875-6e46f1f4-5969-4149-9bb8-b440ffeb2858.png" alt="四种引用状态示意图" class="rounded-lg w-full">
                </div>
                <div class="grid md:grid-cols-2 gap-8">
                    <!-- 强引用和软引用 -->
                    <div>
                        <div class="bg-white border border-gray-200 rounded-lg shadow-sm p-6 mb-6">
                            <h3 class="text-xl font-bold mb-3 text-red-600">1、强引用</h3>
                            <p class="mb-4">
                                代码中普遍存在的类似"Object obj = new Object()"这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。
                            </p>
                            <div class="code-block">
                                <pre class="p-4 overflow-x-auto"><code class="language-java">User u1 = new User(); // u1引用了new User()这个对象,这是强引用</code></pre>
                            </div>
                        </div>
                        
                        <div class="bg-white border border-gray-200 rounded-lg shadow-sm p-6">
                            <h3 class="text-xl font-bold mb-3 text-orange-600">2、软引用</h3>
                            <p class="mb-4">
                                描述有些还有用但并非必需的对象。在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。Java中的类SoftReference表示软引用。
                            </p>
                            <div class="code-block">
                                <pre class="p-4 overflow-x-auto"><code class="language-java">User u1 = new User();
Map<String,Object> map = new HashMap();
map.put("k1",u1);
map = null;</code></pre>
                            </div>
                        </div>
                    </div>
                    
                    <!-- 弱引用和虚引用 -->
                    <div>
                        <div class="bg-white border border-gray-200 rounded-lg shadow-sm p-6 mb-6">
                            <h3 class="text-xl font-bold mb-3 text-yellow-600">3、弱引用</h3>
                            <p>
                                描述非必需对象。被弱引用关联的对象只能生存到下一次垃圾回收之前，垃圾收集器工作之后，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。Java中的类WeakReference表示弱引用。
                            </p>
                        </div>
                        
                        <div class="bg-white border border-gray-200 rounded-lg shadow-sm p-6">
                            <h3 class="text-xl font-bold mb-3 text-blue-600">4、虚引用</h3>
                            <p>
                                虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。
                            </p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Garbage Collectors Section -->
        <section class="mb-20" id="visualization">
            <div class="flex items-center mb-8">
                <i class="fas fa-recycle text-2xl text-blue-500 mr-3"></i>
                <h2 class="text-3xl font-bold section-title">JVM垃圾回收器</h2>
            </div>
            <div class="bg-white rounded-xl shadow-md p-8 card">
                <p class="mb-6 text-lg">
                    <b>如果说垃圾收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。</b>下图展示了7种作用于不同分代的收集器，其中用于回收新生代的收集器包括Serial、PraNew、Parallel Scavenge，回收老年代的收集器包括Serial Old、Parallel Old、CMS，还有用于回收整个Java堆的G1收集器。不同收集器之间的连线表示它们可以搭配使用。
                </p>
                <div class="bg-gray-100 rounded-lg p-4 mb-8">
                    <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1660387151716-e250376d-5330-43b7-84b9-ecf767997493.png" alt="JVM垃圾回收器示意图" class="rounded-lg w-full">
                </div>
                
                <div class="grid md:grid-cols-2 gap-8 mb-8">
                    <div>
                        <div class="mb-6">
                            <h3 class="text-xl font-bold mb-3">新生代回收器</h3>
                            <ul class="list-disc pl-5 space-y-2">
                                <li><b>Serial收集器(复制算法):</b> 新生代单线程收集器，标记和清理都是单线程，优点是简单高效</li>
                                <li><b>ParNew收集器(复制算法):</b> 新生代收并行集器，实际上是Serial收集器的多线程版本</li>
                                <li><b>Parallel Scavenge收集器(复制算法):</b> 新生代并行收集器，追求高吞吐量</li>
                            </ul>
                        </div>
                        
                        <div class="mb-6">
                            <h3 class="text-xl font-bold mb-3">老年代回收器</h3>
                            <ul class="list-disc pl-5 space-y-2">
                                <li><b>Serial Old收集器(标记-整理算法):</b> 老年代单线程收集器</li>
                                <li><b>Parallel Old收集器(标记-整理算法):</b> 老年代并行收集器，吞吐量优先</li>
                                <li><b>CMS收集器(标记-清除算法):</b> 老年代并行收集器，以获取最短回收停顿时间为目标</li>
                            </ul>
                        </div>
                    </div>
                    
                    <div>
                        <div class="bg-blue-50 rounded-lg p-6">
                            <h3 class="text-xl font-bold mb-3">整堆回收器</h3>
                            <p class="mb-4">
                                <b>G1(Garbage First)收集器(标记-整理算法):</b> Java堆并行收集器，G1收集器是JDK1.7提供的一个新收集器，G1收集器基于"标记-整理"算法实现，也就是说不会产生内存碎片。此外，G1收集器不同于之前的收集器的一个重要特点是：G1回收的范围是整个Java堆(包括新生代，老年代)，而前六种收集器回收的范围仅限于新生代或老年代。
                            </p>
                            <div class="bg-gray-100 rounded-lg p-4">
                                <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1660452342035-e8db7da3-a8ed-411b-9396-7d12d340b6ac.png" alt="JDK8默认垃圾回收器" class="rounded-lg w-full">
                            </div>
                            <p class="mt-4 font-bold">jdk8环境下，默认使用 Parallel Scavenge + Parallel Old</p>
                        </div>
                    </div>
                </div>
                
                <!-- Mermaid Visualization -->
                <div class="mt-12">
                    <h3 class="text-2xl font-bold mb-6 text-center">垃圾回收器关系图</h3>
                    <div class="mermaid">
                        graph TD
                            A[垃圾回收器] --> B[新生代回收器]
                            A --> C[老年代回收器]
                            A --> D[整堆回收器]
                            
                            B --> E[Serial收集器]
                            B --> F[ParNew收集器]
                            B --> G[Parallel Scavenge]
                            
                            C --> H[Serial Old]
                            C --> I[Parallel Old]
                            C --> J[CMS]
                            
                            D --> K[G1收集器]
                            
                            E -->|配合使用| H
                            F -->|配合使用| J
                            G -->|配合使用| I
                    </div>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="footer py-12">
        <div class="container mx-auto px-6 text-center">
            <div class="mb-4">
                <h3 class="text-xl font-bold text-white">技术小馆</h3>
            </div>
            <div>
                <a href="http://www.yuque.com/jtostring" class="text-gray-400 hover:text-white transition duration-300">
                    <i class="fas fa-globe mr-2"></i>http://www.yuque.com/jtostring
                </a>
            </div>
        </div>
    </footer>

    <script>
        // Initialize Mermaid
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```